package com.darwin.darwinBitmapEngine.core
{
	import flash.display.BitmapData;
	import flash.events.TimerEvent;
	import flash.geom.Matrix;
	import flash.utils.Timer;
	import flash.utils.getTimer;
	
	/**
	 * 基于BitmapdataArray位图序列的动画对象
	 * @author Roland
	 */
	public class MovieArrayNode extends Node
	{
		private var _timer:Timer;
		/**
		 *	 实例化一个位图序列动画对象
		 * @param bitmapDataList 位图序列
		 * @param frameOffsetList 帧偏移列表,记录每帧单独的偏移位置
		 */
		public function MovieArrayNode(bitmapDataList:Array = null,frameOffsetList:Array = null)
		{
			if(bitmapDataList!=null && bitmapDataList.length>0)
			{
				initMovieNode(bitmapDataList,frameOffsetList);
			}
		}
		
		
		/**
		 * 初始化movieNode对象，对于需要延迟实例化的对象，构造函数执行时可能还未取得相应的数据，
		 * 可通过initMovieNode完成初始化
		 */
		public function initMovieNode(bitmapDataList:Array,frameOffsetList:Array = null):void
		{
			this._bitmapDataList = bitmapDataList;
			this._frameOffsetList = frameOffsetList;
			_frameInterval = 1000/frameRate;
			if(_timer == null)
			{
				_timer = new Timer(_frameInterval);
				_timer.addEventListener(TimerEvent.TIMER,timerEventHandler);
				_timer.start();
			}else{
				_timer.delay = _frameInterval;
			}
			if(bitmapDataList != null)
			{
				_totalFrames = bitmapDataList.length;
			}
			if(_totalFrames<=1)
			{
				stop();
			}
		}
		
		protected function timerEventHandler(event:TimerEvent):void
		{
			if(_isStop == false)
			{
				markChange();
			}
		}
		
		//总帧数 
		private var _totalFrames:int;
		
		/** 
		 * 返回总帧数 
		 */
		public function get totalFrames():int
		{
			return _totalFrames;
		}
		
		//当前帧
		private var _currentFrame:int = 0;
		
		/**
		 * @return 返回当前帧
		 */
		public function get currentFrame():int
		{
			return _currentFrame;
		}
		
		
		//是否处于暂停状态 
		private var _isStop:Boolean = false;
		
		/**
		 * 当前播放是否停止
		 */
		public function get isStop():Boolean
		{
			return _isStop;
		}
		
		/**
		 * 停止动画播放
		 */
		public function stop():void
		{
			_isStop = true;
		}
		
		/**
		 * 开始播放动画 
		 */
		public function play():void
		{
			if(totalFrames > 1)
			{
				_isStop = false;
			}
		}
		
		
		/**
		 * 跳某一帧并播放
		 * @param frame 帧索引 
		 */
		public function gotoAndPlay(frame:int):void
		{
			if(frame >= totalFrames)
			{
				_currentFrame = totalFrames - 1;
			}else{
				_currentFrame = frame;
			}
			if(totalFrames > 1)
			{
				_isStop = false;
			}
		}
		
		/**
		 * 停止到某一帧 
		 * @param frame 帧索引
		 */
		public function gotoAndStop(frame:int):void
		{
			if(frame >= totalFrames)
			{
				_currentFrame = totalFrames - 1;
			}else{
				_currentFrame = frame;
			}
			_isStop = true;
		}
		
		/**
		 * 将播放头转到下一帧并停止
		 */
		public function nextFrame():void
		{
			if(_currentFrame+1 >= totalFrames)
			{
				_currentFrame = totalFrames - 1;
			}else{
				_currentFrame += 1;
			}
			_isStop = true;
		}
		
		/**
		 * 将播放头转到上一帧并停止
		 */
		public function prevFrame():void
		{
			if(_currentFrame-1 < 0)
			{
				_currentFrame = 0;
			}else{
				_currentFrame -= 1;
			}
			_isStop = true;
		}
		
		private var _frameOffsetList:Array;

		/**
		 *	帧偏移列表,记录每帧单独的偏移位置，没有时默认每帧单独偏移为0
		 */
		public function get frameOffsetList():Array
		{
			return _frameOffsetList;
		}

		/**
		 * @private
		 */
		public function set frameOffsetList(value:Array):void
		{
			_frameOffsetList = value;
		}

		
		private var _bitmapDataList:Array;

		/**
		 *	 位图序列
		 */
		public function get bitmapDataList():Array
		{
			return _bitmapDataList;
		}

		/**
		 * @private
		 */
		public function set bitmapDataList(value:Array):void
		{
			_bitmapDataList = value;
		}
		
		
		//两帧间隔时间 
		private var _frameInterval:int;
		
		/**
		 * 返回两帧间隔时间
		 */
		protected function get frameInterval():int
		{
			return _frameInterval;
		}
		
		//帧频  
		private var _frameRate:int = 24;
		
		//上一次执行渲染时间 
		private var _preTime:int = 0;
		
		/**
		 * 上一次渲染时间
		 */
		protected function get preTime():int
		{
			return _preTime;
		}
		
		protected function set preTime(value:int):void
		{
			_preTime = value;
		}
		
		private var _renderFrame:int = -1;
		
		private var _orgBitmapData:BitmapData;
		/** 
		 * 渲染处理 
		 */
		override public function render():void
		{
			var $currentTime:int = getTimer();
			if($currentTime - preTime > frameInterval)
			{
				preTime = $currentTime;
				if(this.rect != null)
				{
					if(_renderFrame == currentFrame && !isStop)
					{
						_currentFrame++;
						if(_currentFrame >= totalFrames)
						{
							_currentFrame = 0;
						}
					}
					if(_bitmapDataList)
					{
						if(_orgBitmapData != _bitmapDataList[_currentFrame])
						{
							_orgBitmapData = _bitmapDataList[_currentFrame];
							this.bitmapData = _orgBitmapData;
							if(_frameOffsetList && _frameOffsetList[_currentFrame])
							{
								this._x = _orgX + _frameOffsetList[_currentFrame].x * _scaleX;
								this._y = _orgY + _frameOffsetList[_currentFrame].y * _scaleY;
							}else{
								this._x = _orgX;
								this._y = _orgY;
							}
						}
					}
					_renderFrame = currentFrame;
				}
				
			}
		}
		
		protected var _orgX:int = 0;
		
		override public function set x(value:Number):void
		{
			super.x = value;
			_orgX = value;
			if(_frameOffsetList && _frameOffsetList[_currentFrame])
			{
				this._x = _orgX + _frameOffsetList[_currentFrame].x;
			}
		}
		
		protected var _orgY:int = 0;
		
		override public function set y(value:Number):void
		{
			super.y = value;
			_orgY = value;
			if(_frameOffsetList && _frameOffsetList[_currentFrame])
			{
				this._y = _orgY + _frameOffsetList[_currentFrame].y;
			}
		}
		
		/**
		 *	不带帧偏移的原始x位置 
		 * @return 
		 * 
		 */
		public function get orgX():int
		{
			return _orgX;
		}
		
		/**
		 *	不带帧偏移的原始y位置 
		 * @return 
		 * 
		 */
		public function get orgY():int
		{
			return _orgY;
		}

		/**
		 * 帧速率 
		 */
		public function get frameRate():int
		{
			return _frameRate;
		}
		
		/**
		 * @private
		 */
		public function set frameRate(value:int):void
		{
			_frameRate = Math.max(value,1);
			_frameInterval = 1000/frameRate;
			if(_timer)_timer.delay = _frameInterval;
		}

		/**
		 *	销毁所有资源 停止一切逻辑动作，在未从场景中移除前调用此方法将导致异常
		 */
		public function destroy():void
		{
			if(_timer)
			{
				_timer.stop();
				_timer.removeEventListener(TimerEvent.TIMER,timerEventHandler);
			}
			_timer = null;

			bitmapData = null;
			filter = null;
			_bitmapDataList = null;
		}
	}
}